package com.hy;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Created With IntelliJ IDEA.
 * Descriptions:
 * User:Mr.Du
 * Date:2024/8/18
 * Time:20:12
 */
public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int k = in.nextInt();
        int[]nums = new int[n];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            nums[i] = in.nextInt();
        }
        long res=sectionDel(nums,k);
        System.out.println(res);
    }

    /*
    思路 :  滑动窗口
    因为 元素 都大于 1  所以 所有的 0  只能来自 与 2  5 两个因子
    例如  25 6  15 4  等 即5 的倍数 或者 2 的倍数  二者相乘 才能多出1个 零
    或者 本身既是2的倍数 又是 五的倍数 那就是 本身就 携带零的;
     */
    public static long sectionDel(int[]nums, int k) {
        // i 位置包含 几个 2 这个因子  // 例如20  20/2=10  10/2=5  也就是包含两个 2
        int[] countBy2 = new int[nums.length];
        //同理 nums[i] 包含几个 5 这个因子
        int[] countBy5 = new int[nums.length];
        // 2 和 5  因子 的总数
        int total2 = 0;
        int total5 = 0;

        for (int i = 0; i < nums.length; i++) {
            while (nums[i] % 2 == 0) {
                nums[i] /= 2;
                countBy2[i]++;
                total2++;
            }
            while (nums[i] % 5 == 0) {
                nums[i] /= 5;
                countBy5[i]++;
                total5++;
            }
        }
        // 滑动窗口计算 可以有多少个可删除的   连续 子序列 注意是连续 ,不能跳着删的
        int l = 0;
        long res = 0;
        /* 滑动窗口统计的是可以删除的 区间 有几个
         依旧 有 dp的思想在 例如 只有一个 元素 的区间
         1  可删除的数字就一个
         1 2  可删除的 区间 1 , 2  , 1 2  三个
         1 2 3 可删除区间   1 ,2 ,1 2, 3 ,2 3,1 2 3  六个
           就可以发现规律 了 从后向前 看  例如 多出一个3 的时候  可删除的区间
             多了  3 ,2 3,1 2 3  这三个 再加上 只有 1 2 两个数字时可组成的区间
             这样 从前向后推导
             dp[i]  含义  共 i个数 可组成的连续子序列共 dp[i]个
             dp[1]=1  dp[i]=dp[i-1]+i
         */
        for (int r = 0; r < nums.length; r++) {
            total2 -= countBy2[r];
            total5 -= countBy5[r];
            // 可以删除的区间统计个数 ,如果遇到 不能删的 元素(注意是元素)
            //就调整 l 的位置 向后移动,(r的每次右移 都在尝试 寻找连续可删 区间的长度)
            while (Math.min(total2, total5) < k && l <= r) {
                //把途中的 2 或者 5 补充回来 ,直到满足要求
                total2 += countBy2[l];
                total5 += countBy5[l];
                l++;
            }
            // 之所以是 r-l+1 原因就类似于 使用 dp[i];
            res += r - l + 1;
        }
        return res;
    }
}
